home *** CD-ROM | disk | FTP | other *** search
/ SGI Developer Toolbox 6.1 / SGI Developer Toolbox 6.1 - Disc 4.iso / src / haeberli / libgutil / sample.c < prev    next >
C/C++ Source or Header  |  1994-08-01  |  4KB  |  246 lines
  1. /*
  2.  * Copyright 1991, 1992, 1993, 1994, Silicon Graphics, Inc.
  3.  * All Rights Reserved.
  4.  *
  5.  * This is UNPUBLISHED PROPRIETARY SOURCE CODE of Silicon Graphics, Inc.;
  6.  * the contents of this file may not be disclosed to third parties, copied or
  7.  * duplicated in any form, in whole or in part, without the prior written
  8.  * permission of Silicon Graphics, Inc.
  9.  *
  10.  * RESTRICTED RIGHTS LEGEND:
  11.  * Use, duplication or disclosure by the Government is subject to restrictions
  12.  * as set forth in subdivision (c)(1)(ii) of the Rights in Technical Data
  13.  * and Computer Software clause at DFARS 252.227-7013, and/or in similar or
  14.  * successor clauses in the FAR, DOD or NASA FAR Supplement. Unpublished -
  15.  * rights reserved under the Copyright Laws of the United States.
  16.  */
  17. /*
  18.  *    sample - 
  19.  *        Support for managing sample sets.
  20.  *
  21.  *                Paul Haeberli - 1988
  22.  */
  23. #include "ss.h"
  24. #include "vect.h"
  25. #include "stdio.h"
  26. #include "resource.h"
  27. #include "chunkarena.h"
  28.  
  29. static chunkarena *samparena;
  30.  
  31. sample *samplemalloc()
  32. {
  33.     if(!samparena)
  34.     samparena = newchunkalloc(sizeof(sample));
  35.     return (sample *)chunkalloc(samparena);
  36. }
  37.  
  38. sfree(s)
  39. sample *s;
  40. {
  41.     chunkfree(samparena,s);
  42. }
  43.  
  44. sample *snew(p,c,at0,at1,at2,at3)
  45. vect *p, *c;
  46. int at0, at1, at2, at3;
  47. {
  48.     sample *s;
  49.  
  50.     s = samplemalloc();
  51.     s->xpos = POSSCALE*p->x;
  52.     s->ypos = POSSCALE*p->y;
  53.     s->r = 255*c->x;
  54.     s->g = 255*c->y;
  55.     s->b = 255*c->z;
  56.     s->a = 255*c->w;
  57.     s->at0 = at0;
  58.     s->at1 = at1;
  59.     s->at2 = at2;
  60.     s->at3 = at3;
  61.     return s;
  62. }
  63.  
  64. sample *sclone(s)
  65. sample *s;
  66. {
  67.     sample *ns;
  68.  
  69.     ns = samplemalloc();
  70.     *ns = *s;
  71.     return ns;
  72. }
  73.  
  74. sprint(s)
  75. sample *s;
  76. {
  77.     printf("sample: pos %f %f  color %3d %3d %3d %3d  attribs: %3d %3d %3d\n",
  78.     s->xpos/(float)POSSCALE,s->ypos/(float)POSSCALE,
  79.     s->r, s->g, s->b, s->a,
  80.     s->at0, s->at1, s->at2);
  81. }
  82.  
  83. sampleset *ssnew()
  84. {
  85.     sampleset *ss;
  86.  
  87.     ss = (sampleset *)mymalloc(sizeof(sampleset));
  88.     ss->head = 0;
  89.     ss->tail = 0;
  90.     ss->nsamples = 0;
  91.     return ss;
  92. }
  93.  
  94. ssfree(ss)
  95. sampleset *ss;
  96. {
  97.     ssclear(ss);
  98.     free(ss);
  99. }
  100.  
  101. ssclear(ss)
  102. sampleset *ss;
  103. {
  104.     sample *s, *ns;
  105.  
  106.     s = ss->head;
  107.     while(s) {
  108.     ns = s->next;
  109.     sfree(s);
  110.     s = ns;
  111.     }
  112.     ss->head = 0;
  113.     ss->tail = 0;
  114.     ss->nsamples = 0;
  115. }
  116.  
  117. sampleset *ssclone(ss)
  118. sampleset *ss;
  119. {
  120.     sampleset *nss;
  121.     sample *s, *ns;
  122.  
  123.     nss = ssnew();
  124.     s = ss->head;
  125.     while(s) {
  126.     ns = sclone(s);
  127.     addsample(nss,ns);
  128.     s = s->next;
  129.     }
  130.     return nss;
  131. }
  132.  
  133. ssprint(ss)
  134. sampleset *ss;
  135. {
  136.     sample *s;
  137.  
  138.     printf("sample set with %d samples siz dir brush\n",ss->nsamples);
  139.     s = ss->head;
  140.     while(s) {
  141.     sprint(s);
  142.     s = s->next;
  143.     }
  144. }
  145.  
  146. addsample(ss,s)
  147. sampleset *ss;
  148. sample *s;
  149. {
  150.     s->next = 0;
  151.     if(!ss->tail) {
  152.         ss->head = s;
  153.         ss->tail = s;
  154.         ss->nsamples = 1;
  155.     } else {
  156.     ss->tail->next = s;
  157.     ss->tail = s;
  158.         ss->nsamples++;
  159.     }
  160. }
  161.  
  162. sslerp(ss0,ss1,ss,p)
  163. sampleset *ss0, *ss1, *ss;
  164. float p;
  165. {
  166.     sample *s0, *s1, *s, *ns;
  167.  
  168.     ssclear(ss);
  169.     s0 = ss0->head;
  170.     s1 = ss1->head;
  171.     if(!s0 || !s1) 
  172.     return;
  173.     while(1) {
  174.     s = samplemalloc();
  175.     slerp(s0,s1,s,p);
  176.     addsample(ss,s);
  177.     if(s0->next)
  178.         s0 = s0->next;
  179.     if(s1->next)
  180.         s1 = s1->next;
  181.     if((s0->next==0) && (s1->next == 0))
  182.         return;
  183.     }
  184. }
  185.  
  186. slerp(s0,s1,s,p)
  187. sample *s0, *s1, *s;
  188. float p;
  189. {
  190.     s->xpos = lerp(s0->xpos,s1->xpos,p);
  191.     s->ypos = lerp(s0->ypos,s1->ypos,p);
  192.     s->r = lerp(s0->r,s1->r,p);
  193.     s->g = lerp(s0->g,s1->g,p);
  194.     s->b = lerp(s0->b,s1->b,p);
  195.     s->a = lerp(s0->a,s1->a,p);
  196.     s->at0 = lerp(s0->at0,s1->at0,p);
  197.     s->at1 = lerp(s0->at1,s1->at1,p);
  198.     s->at2 = lerp(s0->at2,s1->at2,p);
  199.     s->at3 = lerp(s0->at3,s1->at3,p);
  200. }
  201.  
  202. sstofile(name,ss)
  203. char *name;
  204. sampleset *ss;
  205. {
  206.     FILE *outf;
  207.     sample *s;
  208.  
  209.     outf = fopen(name,"w");
  210.     if(!outf) {
  211.     fprintf(stderr,"sstofile: can't open output file %s\n",name);
  212.     exit(1);
  213.     }
  214.     fwrite(&ss->nsamples,1,sizeof(int),outf);
  215.     s = ss->head;
  216.     while(s) {
  217.     fwrite(s,1,sizeof(sample),outf);
  218.     s = s->next;
  219.     }
  220.     fclose(outf);
  221. }
  222.  
  223. sampleset *ssfromfile(name)
  224. char *name;
  225. {
  226.     int i, nsamples;
  227.     sampleset *ss;
  228.     sample *s;
  229.     FILE *inf;
  230.  
  231.     inf = res_fopen(name,"r");
  232.     if(!inf) {
  233.     fprintf(stderr,"sstofile: can't open input file %s\n",name);
  234.     exit(1);
  235.     }
  236.     ss = ssnew();
  237.     res_fread(&nsamples,1,sizeof(int),inf);
  238.     for(i=0; i<nsamples; i++) {
  239.     s = samplemalloc();
  240.     res_fread(s,1,sizeof(sample),inf);
  241.     addsample(ss,s);
  242.     }
  243.     res_fclose(inf);
  244.     return ss;
  245. }
  246.